package api

import (
	"gateway/basic/config"
	order "gateway/basic/proto/orderproto"
	"gateway/handler/request"
	"gateway/handler/response"
	"github.com/gin-gonic/gin"
)

// GetLogsByUser 根据用户ID获取操作日志
// @Summary 根据用户ID获取操作日志
// @Description 获取指定用户的操作日志记录
// @Tags 操作日志管理
// @Accept json
// @Produce json
// @Param user_id query string true "用户ID"
// @Param page query int false "页码" default(1)
// @Param page_size query int false "每页数量" default(20)
// @Success 200 {object} response.Response "获取用户日志成功"
// @Failure 400 {object} response.Response "请求参数错误"
// @Failure 500 {object} response.Response "服务器内部错误"
// @Router /v1/operation-log/user [get]
func GetLogsByUser(c *gin.Context) {
	var req request.GetLogsByUserRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		response.ParameterError(c, "请求参数错误: "+err.Error(), err.Error())
		return
	}

	// 调用RPC服务
	rpcReq := &order.GetLogsByUserReq{
		UserId:   req.UserID,
		Page:     req.Page,
		PageSize: req.PageSize,
	}

	rpcResp, err := config.OrderClient.GetLogsByUser(c.Request.Context(), rpcReq)
	if err != nil {
		response.SrvError(c, "获取用户日志失败: "+err.Error(), err.Error())
		return
	}

	if rpcResp.Code != 200 {
		response.SrvError(c, rpcResp.Message, nil)
		return
	}

	response.Success(c, rpcResp.Message, map[string]interface{}{
		"logs":      rpcResp.Logs,
		"total":     rpcResp.Total,
		"page":      rpcResp.Page,
		"page_size": rpcResp.PageSize,
	})
}

// GetLogsByModule 根据模块获取操作日志
// @Summary 根据模块获取操作日志
// @Description 获取指定模块的操作日志记录
// @Tags 操作日志管理
// @Accept json
// @Produce json
// @Param module query string true "模块名称"
// @Param page query int false "页码" default(1)
// @Param page_size query int false "每页数量" default(20)
// @Success 200 {object} response.Response "获取模块日志成功"
// @Failure 400 {object} response.Response "请求参数错误"
// @Failure 500 {object} response.Response "服务器内部错误"
// @Router /v1/operation-log/module [get]
func GetLogsByModule(c *gin.Context) {
	var req request.GetLogsByModuleRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		response.ParameterError(c, "请求参数错误: "+err.Error(), err.Error())
		return
	}

	// 调用RPC服务
	rpcReq := &order.GetLogsByModuleReq{
		Module:   req.Module,
		Page:     req.Page,
		PageSize: req.PageSize,
	}

	rpcResp, err := config.OrderClient.GetLogsByModule(c.Request.Context(), rpcReq)
	if err != nil {
		response.SrvError(c, "获取模块日志失败: "+err.Error(), err.Error())
		return
	}

	if rpcResp.Code != 200 {
		response.SrvError(c, rpcResp.Message, nil)
		return
	}

	response.Success(c, rpcResp.Message, map[string]interface{}{
		"logs":      rpcResp.Logs,
		"total":     rpcResp.Total,
		"page":      rpcResp.Page,
		"page_size": rpcResp.PageSize,
	})
}

// GetLogsByResource 根据资源获取操作日志
// @Summary 根据资源获取操作日志
// @Description 获取指定资源的操作日志记录
// @Tags 操作日志管理
// @Accept json
// @Produce json
// @Param resource_type query string true "资源类型"
// @Param resource_id query string true "资源ID"
// @Param page query int false "页码" default(1)
// @Param page_size query int false "每页数量" default(20)
// @Success 200 {object} response.Response "获取资源日志成功"
// @Failure 400 {object} response.Response "请求参数错误"
// @Failure 500 {object} response.Response "服务器内部错误"
// @Router /v1/operation-log/resource [get]
func GetLogsByResource(c *gin.Context) {
	var req request.GetLogsByResourceRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		response.ParameterError(c, "请求参数错误: "+err.Error(), err.Error())
		return
	}

	// 调用RPC服务
	rpcReq := &order.GetLogsByResourceReq{
		ResourceType: req.ResourceType,
		ResourceId:   req.ResourceID,
		Page:         req.Page,
		PageSize:     req.PageSize,
	}

	rpcResp, err := config.OrderClient.GetLogsByResource(c.Request.Context(), rpcReq)
	if err != nil {
		response.SrvError(c, "获取资源日志失败: "+err.Error(), err.Error())
		return
	}

	if rpcResp.Code != 200 {
		response.SrvError(c, rpcResp.Message, nil)
		return
	}

	response.Success(c, rpcResp.Message, map[string]interface{}{
		"logs":      rpcResp.Logs,
		"total":     rpcResp.Total,
		"page":      rpcResp.Page,
		"page_size": rpcResp.PageSize,
	})
}

// GetLogsByCondition 根据条件获取操作日志
// @Summary 根据条件获取操作日志
// @Description 根据多种条件查询操作日志记录
// @Tags 操作日志管理
// @Accept json
// @Produce json
// @Param request body request.GetLogsByConditionRequest true "查询条件"
// @Success 200 {object} response.Response "获取条件日志成功"
// @Failure 400 {object} response.Response "请求参数错误"
// @Failure 500 {object} response.Response "服务器内部错误"
// @Router /v1/operation-log/condition [post]
func GetLogsByCondition(c *gin.Context) {
	var req request.GetLogsByConditionRequest
	if err := c.ShouldBind(&req); err != nil {
		response.ParameterError(c, "请求参数错误: "+err.Error(), err.Error())
		return
	}

	// 调用RPC服务
	rpcReq := &order.GetLogsByConditionReq{
		UserId:       req.UserID,
		Module:       req.Module,
		Operation:    req.Operation,
		ResourceType: req.ResourceType,
		ResourceId:   req.ResourceID,
		LogType:      req.LogType,
		Result:       req.Result,
		StartTime:    req.StartTime,
		EndTime:      req.EndTime,
		IpAddress:    req.IPAddress,
		Page:         req.Page,
		PageSize:     req.PageSize,
	}

	rpcResp, err := config.OrderClient.GetLogsByCondition(c.Request.Context(), rpcReq)
	if err != nil {
		response.SrvError(c, "获取条件日志失败: "+err.Error(), err.Error())
		return
	}

	if rpcResp.Code != 200 {
		response.SrvError(c, rpcResp.Message, nil)
		return
	}

	response.Success(c, rpcResp.Message, map[string]interface{}{
		"logs":      rpcResp.Logs,
		"total":     rpcResp.Total,
		"page":      rpcResp.Page,
		"page_size": rpcResp.PageSize,
	})
}

// GetLogStatistics 获取日志统计信息
// @Summary 获取日志统计信息
// @Description 获取操作日志的统计信息
// @Tags 操作日志管理
// @Accept json
// @Produce json
// @Param start_time query string false "开始时间"
// @Param end_time query string false "结束时间"
// @Success 200 {object} response.Response "获取日志统计成功"
// @Failure 500 {object} response.Response "服务器内部错误"
// @Router /v1/operation-log/statistics [get]
func GetLogStatistics(c *gin.Context) {
	var req request.GetLogStatisticsRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		response.ParameterError(c, "请求参数错误: "+err.Error(), err.Error())
		return
	}

	// 调用RPC服务
	rpcReq := &order.GetLogStatisticsReq{
		StartTime: req.StartTime,
		EndTime:   req.EndTime,
	}

	rpcResp, err := config.OrderClient.GetLogStatistics(c.Request.Context(), rpcReq)
	if err != nil {
		response.SrvError(c, "获取日志统计失败: "+err.Error(), err.Error())
		return
	}

	if rpcResp.Code != 200 {
		response.SrvError(c, rpcResp.Message, nil)
		return
	}

	response.Success(c, rpcResp.Message, map[string]interface{}{
		"stats": rpcResp.Stats,
	})
}

// DeleteOldLogs 删除旧日志
// @Summary 删除旧日志
// @Description 删除指定时间之前的旧日志记录
// @Tags 操作日志管理
// @Accept json
// @Produce json
// @Param request body request.DeleteOldLogsRequest true "删除请求"
// @Success 200 {object} response.Response "删除旧日志成功"
// @Failure 400 {object} response.Response "请求参数错误"
// @Failure 500 {object} response.Response "服务器内部错误"
// @Router /v1/operation-log/delete-old [post]
func DeleteOldLogs(c *gin.Context) {
	var req request.DeleteOldLogsRequest
	if err := c.ShouldBind(&req); err != nil {
		response.ParameterError(c, "请求参数错误: "+err.Error(), err.Error())
		return
	}

	// 调用RPC服务
	rpcReq := &order.DeleteOldLogsReq{
		BeforeTime: req.BeforeTime,
	}

	rpcResp, err := config.OrderClient.DeleteOldLogs(c.Request.Context(), rpcReq)
	if err != nil {
		response.SrvError(c, "删除旧日志失败: "+err.Error(), err.Error())
		return
	}

	if rpcResp.Code != 200 {
		response.SrvError(c, rpcResp.Message, nil)
		return
	}

	response.Success(c, rpcResp.Message, nil)
}

